home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / pangomm-1.4 / pangomm / layoutline.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-20  |  8.6 KB  |  223 lines
  1. // -*- c++ -*-
  2. // Generated by gtkmmproc -- DO NOT MODIFY!
  3. #ifndef _PANGOMM_LAYOUTLINE_H
  4. #define _PANGOMM_LAYOUTLINE_H
  5.  
  6. #include <glibmm.h>
  7.  
  8. /* $Id: layoutline.hg,v 1.4 2004/02/03 11:06:52 murrayc Exp $ */
  9.  
  10. /* layoutline.h
  11.  *
  12.  * Copyright (C) 1998-1999 The gtkmm Development Team
  13.  *
  14.  * This library is free software; you can redistribute it and/or
  15.  * modify it under the terms of the GNU Library General Public
  16.  * License as published by the Free Software Foundation; either
  17.  * version 2 of the License, or (at your option) any later version.
  18.  *
  19.  * This library is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22.  * Library General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU Library General Public
  25.  * License along with this library; if not, write to the Free
  26.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  */
  28.  
  29. #include <glibmm/slisthandle.h> // For the Glib::SListHandle typedef
  30. #include <pangomm/rectangle.h>
  31. #include <pango/pango-layout.h>
  32.  
  33.  
  34. namespace Pango
  35. {
  36.  
  37. class Layout;
  38.  
  39. /** A Pango::LayoutLine represents one of the lines resulting from laying out a paragraph via Pango::Layout.
  40.  * Pango::LayoutLine objects are obtained by calling Pango::Layout::get_line()
  41.  * and are only valid until the text, attributes, or settings of the parent Pango::Layout are modified.
  42.  * Routines for rendering Pango::Layout objects are provided in code specific to each rendering system.
  43.  */
  44. class LayoutLine
  45. {
  46.   public:
  47. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  48.   typedef LayoutLine CppObjectType;
  49.   typedef PangoLayoutLine BaseObjectType;
  50. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  51.  
  52.  
  53.   // For use with Glib::RefPtr<> only.
  54.   void reference()   const;
  55.   void unreference() const;
  56.  
  57.   ///Provides access to the underlying C instance.
  58.   PangoLayoutLine*       gobj();
  59.  
  60.   ///Provides access to the underlying C instance.
  61.   const PangoLayoutLine* gobj() const;
  62.  
  63.   ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  64.   PangoLayoutLine* gobj_copy() const;
  65.  
  66. protected:
  67.   // Do not derive this.  Pango::LayoutLine can neither be constructed nor deleted.
  68.   LayoutLine();
  69.   void operator delete(void*, size_t);
  70.  
  71. private:
  72.   // noncopyable
  73.   LayoutLine(const LayoutLine&);
  74.   LayoutLine& operator=(const LayoutLine&);
  75.  
  76.  
  77. public:
  78.  
  79.   
  80.   /** Converts from x offset to the byte index of the corresponding
  81.    * character within the text of the layout. If @a x_pos  is outside the line,
  82.    *  @a index  and @a trailing  will point to the very first or very last position
  83.    * in the line. This determination is based on the resolved direction
  84.    * of the paragraph; for example, if the resolved direction is
  85.    * right-to-left, then an X position to the right of the line (after it)
  86.    * results in 0 being stored in @a index  and @a trailing . An X position to the
  87.    * left of the line results in @a index  pointing to the (logical) last
  88.    * grapheme in the line and @a trailing  being set to the number of characters
  89.    * in that grapheme. The reverse is true for a left-to-right line.
  90.    * @param x_pos The x offset (in Pango::GlyphUnit)
  91.    * from the left edge of the line.
  92.    * @param index Location to store calculated byte index for
  93.    * the grapheme in which the user clicked.
  94.    * @param trailing Location to store a integer indicating where
  95.    * in the grapheme the user clicked. It will either
  96.    * be zero, or the number of characters in the
  97.    * grapheme. 0 represents the trailing edge of the grapheme.
  98.    * @return <tt>false</tt> if @a x_pos  was outside the line, <tt>true</tt> if inside.
  99.    */
  100.   bool x_to_index(int x_pos, int& index, int& trailing) const;
  101.  
  102.   /** Converts an index within a line to a @a x position.
  103.    * @param index Byte offset of a grapheme within the layout.
  104.    * @param trailing  A boolean indicating the edge of the grapheme to retrieve the position of. If <tt>false</tt>, the trailing edge of the grapheme, if <tt>true</tt> the leading of the grapheme. 
  105.    * @return The x offset (in thousands of a device unit).
  106.    */
  107.   int index_to_x(int index, bool trailing) const;
  108.   
  109.  
  110.   /** Get a list of visual ranges corresponding to a given logical range.
  111.    * This list is not necessarily minimal - there may be consecutive ranges which are adjacent.
  112.    * The ranges will be sorted from left to right. The ranges are with respect to the
  113.    * left edge of the entire layout, not with respect to the line.
  114.    * @param start_index The start byte index of the logical range.
  115.    * If the value of @a start_index is less than the start index for the line,
  116.    * then the first range will extend all the way to the leading edge of the layout.
  117.    * Otherwise it will start at the leading edge of the first character.
  118.    * @param end_index The end byte index of the logical range.
  119.    * If the value of @a end_index is greater than the end index for the line,
  120.    * then the last range will extend all the way to the trailing edge of the layout.
  121.    * Otherwise, it will end at the trailing edge of the last character.
  122.    * @return An array of ranges represented by pairs of integers marking the start and end pixel coordinates of the ranges.
  123.    */
  124.   Glib::ArrayHandle<std::pair<int,int> > get_x_ranges(int start_index, int end_index) const;
  125.  
  126.   
  127.   /** Compute the logical and ink extents of a layout line. See the documentation
  128.    * for Pango::Font::get_glyph_extents() for details about the interpretation
  129.    * of the rectangles.
  130.    * @param ink_rect Rectangle used to store the extents of the glyph string as drawn.
  131.    * @param logical_rect Rectangle used to store the logical extents of the glyph string.
  132.    */
  133.   void get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
  134.  
  135.   /** Compute the ink extents of a layout line.
  136.    * @return The extents of the layout line as drawn.
  137.    */
  138.   Rectangle get_ink_extents() const;
  139.  
  140.   /** Compute the logical extents of a layout line.
  141.    * @return The logical extents of the layout line.
  142.    */
  143.   Rectangle get_logical_extents() const;
  144.  
  145.   
  146.   /** Compute the logical and ink extents of a layout line. See the documentation
  147.    * for Pango::Font::get_glyph_extents() for details about the interpretation
  148.    * of the rectangles. The returned rectangles are in device units, as
  149.    * opposed to pango_layout_line_get_extents(), which returns the extents in
  150.    * units of device unit / PANGO_SCALE.
  151.    * @param ink_rect Rectangle used to store the extents of the glyph string as drawn.
  152.    * @param logical_rect Rectangle used to store the logical extents of the glyph string.
  153.    */
  154.   void get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const;
  155.  
  156.   /** Compute the ink extents of a layout line in device units.
  157.    * @return The extents of the layout line as drawn.
  158.    */
  159.   Rectangle get_pixel_ink_extents() const;
  160.  
  161.   /** Compute the logical extents of a layout line in device units.
  162.    * @return The logical extents of the layout line.
  163.    */
  164.   Rectangle get_pixel_logical_extents() const;
  165.  
  166.   Glib::RefPtr<Pango::Layout> get_layout();
  167.   Glib::RefPtr<const Pango::Layout> get_layout() const;
  168.   //_MEMBER_SET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)
  169.   int get_length() const;
  170.   int get_start_index() const;
  171.     
  172.  
  173. };
  174.  
  175. } // namespace Pango
  176.  
  177.  
  178. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  179. namespace Glib
  180. {
  181. // forward declaration needed by LayoutLineTraits
  182. Glib::RefPtr<Pango::LayoutLine> wrap(PangoLayoutLine* object, bool take_copy /* = false */);
  183.  
  184. } // namespace Glib
  185. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  186.  
  187.  
  188. namespace Pango
  189. {
  190.  
  191. struct LayoutLineTraits
  192. {
  193.   typedef Glib::RefPtr<LayoutLine>  CppType;
  194.   typedef PangoLayoutLine *         CType;
  195.   typedef PangoLayoutLine *         CTypeNonConst;
  196.  
  197.   static CType   to_c_type      (const CppType& ptr) { return Glib::unwrap(ptr);     }
  198.   static CType   to_c_type      (CType          ptr) { return ptr;                   }
  199.   static CppType to_cpp_type    (CType          ptr) { return Glib::wrap(ptr, true); }
  200.   static void    release_c_type (CType          ptr) { pango_layout_line_unref(ptr); }
  201. };
  202.  
  203. typedef Glib::SListHandle< Glib::RefPtr<LayoutLine>, LayoutLineTraits > SListHandle_LayoutLine;
  204. typedef Glib::SListHandle< Glib::RefPtr<const LayoutLine>, LayoutLineTraits > SListHandle_ConstLayoutLine;
  205.  
  206. } // namespace Pango
  207.  
  208.  
  209. namespace Glib
  210. {
  211.  
  212.   /** @relates Pango::LayoutLine
  213.    * @param object The C instance
  214.    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
  215.    * @result A C++ instance that wraps this C instance.
  216.    */
  217.   Glib::RefPtr<Pango::LayoutLine> wrap(PangoLayoutLine* object, bool take_copy = false);
  218.  
  219. } // namespace Glib
  220.  
  221. #endif /* _PANGOMM_LAYOUTLINE_H */
  222.  
  223.